Simplification of UML/OCL schemas for efficient reasoning

Ensuring the correctness of a conceptual schema is an essential task in order to avoid the propagation of errors during software development. The kind of reasoning required to perform such task is known to be exponential for UML class diagrams alone and even harder when considering OCL constraints. Motivated by this issue, we propose an innovative method aimed at removing constraints and other UML elements of the schema to obtain a simplified one that preserve the same reasoning outcomes. In this way, we can reason about the correctness of the initial artifact by reasoning on a simplified version of it. Thus, the efficiency of the reasoning process is significantly improved. In addition, since our method is independent from the reasoning engine used, any reasoning method may benefit from it.Peer ReviewedPostprint (author's final draft

Verificació i validació d'esquemes conceptuals UML/OCL amb operacions

En aquest projecte es construeix una eina per l'anàlisi d'esquemes conceptuals amb operacions basat en la reducció del problema a un problema de lògica de 1r ordre. A través d'uns tests predefinits i l'opció de definir-ne de propis, un usuari pot provar la correcció d'un esquema

Computing repairs for constraint violations in UML/OCL conceptual schemas

Updating the contents of an information base may violate some of the constraints defined over the schema. The classical way to deal with this problem has been to reject the requested update when its application would lead to some constraint violation. We follow here an alternative approach aimed at automatically computing the repairs of an update, i.e., the minimum additional changes that, when applied together with the requested update, bring the information base to a new state where all constraints are satisfied. Our approach is independent of the language used to define the schema and the constraints, since it is based on a logic formalization of both, although we apply it to UML and OCL because they are widely used in the conceptual modeling community. Our method can be used for maintaining the consistency of an information base after the application of some update, and also for dealing with the problem of fixing up non-executable operations. The fragment of OCL that we use to define the constraints has the same expressiveness as relational algebra and we also identify a subset of it which provides some nice properties in the repair-computation process. Experiments are conducted to analyze the efficiency of our approach.Peer ReviewedPostprint (author's final draft

TINTIN : comprobación incremental de aserciones SQL

Ninguno de los SGBD más populares del momento implementa aserciones SQL, obligando así a implementar manualmente su comprobación. Por ello, presentamos TINTIN: una aplicación que genera automáticamente el código SQL para comprobar aserciones. Dicho código captura las tuplas insertadas/borradas en una transacción, comprueba que ninguna de ellas viole ninguna aserción mediante consultas SQL, y materializa los cambios en caso que sean satisfechas. La eficiencia del código se basa en la comprobación incremental de las aserciones.Peer ReviewedPostprint (published version

Incremental checking of OCL constraints through SQL queries

We propose a new method for efficiently checking OCL constraints by means of SQL queries. That is, an OCL constraint is satisfied if its corresponding SQL query returns the empty set. Such queries are computed in an incremental way since, whenever a change in the data occurs, only the constraints that may be violated because of such change are checked and only the relevant values given by the change are taken into account. Moreover, the queries we generate do not contain nested subqueries nor procedures. In this way, we take advantage of relational DBMS capabilities and we get an efficient check of OCL constraints.Postprint (published version

OCLuniv: Expressive UML/OCL conceptual schemas for finite reasoning

Full UML/OCL is so expressive that most reasoning tasks are known to be undecidable in schemas defined with these languages. To tackle this situation, literature has proposed mainly three decidable fragments of UML/OCL: UML with no OCL, UML with limited OCL and no maximum cardinality constraints (OCL-Lite), and UML with limited OCL with no minimum cardinality constraints (OCL UNIVUNIV ). Since most conceptual schemas make use of OCL together with min and max cardinalities, this poses a strong limitation to current proposals. In this paper, we go beyond these limits by showing that OCL UNIVUNIV with acyclic min cardinality constraints and path acyclicity constraints also preserves decidability. In this way, we establish a language that can deal with most of UML/OCL identified constraint patterns. We also empirically test the expressiveness of this language through different UML/OCL case studies.Peer ReviewedPostprint (author's final draft

Ejecución de operaciones de un esquema conceptual de forma persistente y consistente

El objetivo de la presente tesis es la ejecución de operaciones de un esquema conceptual de forma persistente y consistente. Es decir, los efectos de las operaciones son persistidos automáticamente en una base de datos a la vez que se garantiza que su ejecución no conlleva, en ningún caso, la violación de restricciones de integridad definidas en el esquema. De esta forma, se automatiza la construcción de las capas de dominio y persistencia de un Sistema de Información requiriendo únicamente la implementación de un interfaz gráfica para su uso.Peer ReviewedPreprin

TINTIN: a Tool for INcremental INTegrity checking of Assertions in SQL Server

We present TINTIN, a tool to perform efficient integrity checking of SQL assertions in SQL Server. TINTIN rewrites each assertion into a set of standard SQL queries that, given a set of insertions and deletions of tuples, allow to incrementally compute whether this update violates the assertion or not. If one of such queries returns a non empty answer, then the assertion is violated. Efficiency is achieved by evaluating only those data and those assertions that can actually be violated according to the update. TINTIN is aimed at two different purposes. First, to show the feasibility of our approach by implementing it on a commercial relational DBMS. Second, to illustrate that the efficiency we achieve is good enough for making assertions to be used in practice.Peer ReviewedPostprint (published version

Generating valid test data through data cloning

One of the most difficult, time-consuming and error-prone tasks during software testing is that of manually generating the data required to properly run the test. This is even harder when we need to generate data of a certain size and such that it satisfies a set of conditions, or business rules, specified over an ontology. To solve this problem, some proposals exist to automatically generate database sample data. However, they are only able to generate data satisfying primary or foreign key constraints but not more complex business rules in the ontology. We propose here a more general solution for generating test data which is able to deal with expressive business rules. Our approach, which is entirely based on the chase algorithm, first generates a small sample of valid test data (by means of an automated reasoner), then clones this sample data, and finally, relates the cloned data with the original data. All the steps are performed iteratively until a valid database of a certain size is obtained. We theoretically prove the correctness of our approach, and experimentally show its practical applicability.This work is partially supported by the SUDOQU project, PID2021-126436OB-C21 from MCIN/AEI, 10.13039/501100011033, FEDER, UE and by the Generalitat de Catalunya, Spain (under 2017-SGR-1749); Sergi Nadal is partly supported by the Spanish Ministerio de Ciencia e Innovación , as well as the European Union - NextGenerationEU, under project FJC2020-045809-I.Peer ReviewedPostprint (published version

UQJG: Identifying transactions that collaborate to violate an SQL assertion

An SQL assertion is a declarative statement about data that must always be satisfied in any database state. Assertions were introduced in the SQL92 standard but no commercial DBMS has implemented them so far. Some approaches have been proposed to incrementally determine whether a transaction violates an SQL assertion, but they assume that transactions are applied in isolation, hence not considering the problem of concurrent transaction executions that collaborate to violate an assertion. This is the main stopper for its commercial implementation. To handle this problem, we have developed a technique for efficiently serializing concurrent transactions that might interact to violate an SQL assertion.Peer ReviewedPostprint (author's final draft